.. _topic8-example:

*************************
File Descriptor Example
*************************
    ::

        /*
        *  process 1 reads from stdin and writes to a pipe to process 2.
        *  process 2 reads from pipe from process 1, converts to caps and
        *            writes to pipe to process 3
        *  process 3 reads from pipe from process 2 and writes to stdout.
        */
        #define STDIN 0
        #define STDOUT 1
        #include <sys/types.h>
        #include <unistd.h>
        
        int main(void)
        {
           char *process="./cat";       /* process to exec */
           char *caps="caps";
           int fd[2];                     /* pipe file desc. */
        
           pipe(fd);
           if( fork() != 0 ) {/* process 1, parent */
              close(fd[0]);   /* parent does not read from pipe */
              close(STDOUT);  /* prepare to redirect stdout     */
              dup(fd[1]);     /* stdout now writes to the pipe  */
              close(fd[1]);   /* extra file descriptor          */ 
              execl( process, process, 0 ); /* call cat         */
           } else {           /* process 2, child */
              /*
               * First deal with pipe between proc. 1 & 2.
              */
              close(fd[1]);   /* child does not write to pipe   */
              close(STDIN);   /* prepare to redirect stdin      */
              dup(fd[0]);     /* stdin now reads from the pipe  */
              close(fd[0]);   /* extra file descriptor          */ 
              /*
               * now for process 3. and pipe between 2 & 3.
              */
              pipe(fd);
              if( fork() != 0 ) {/* process 2, parent of second fork  */
                 close(fd[0]);   /* parent does not read from pipe */
                 close(STDOUT);  /* prepare to redirect stdout     */
                 dup(fd[1]);     /* stdout now writes to the pipe  */
                 close(fd[1]);   /* extra file descriptor          */ 
                 execl( process, process, caps, 0 ); /* call cat   */
              } else {           /* process 3, child of second fork */
                 close(fd[1]);   /* child does not write to pipe   */
                 close(STDIN);   /* prepare to redirect stdin      */
                 dup(fd[0]);     /* stdin now reads from the pipe  */
                 close(fd[0]);   /* extra file descriptor          */ 
                 execl( process, process, 0 ); /* call cat         */
             }   
           }
           return 0;
        }


    ::

        /*
         * This program just reads from stdin and prints to stdout
         * If the word 'caps' is used as an argument, it converts to caps.
        */
        
        #include <stdio.h>
        #include <string.h>
        
        int makecap( int );
        
        int main(int argc, char **argv)
        {
           int c;
        
           if( (argc == 2 ) && ( strcmp(argv[1], "caps")  == 0  ) ) {
              while( (c=getchar()) !=EOF )
                 putchar(makecap(c));
           } else {
              while( (c=getchar()) !=EOF )
                 putchar(c);
           }
           fflush(stdout);
           return 0;
        }
        
        int makecap( int c )
        {
           if( ( c >= 'a' ) && ( c <= 'z' ) )
              return( c - 'a' + 'A' );
           else
              return( c );
        }


--------------

    ::

        /*
         * Send a signal from a child process to the parent.
         * Parent will catch the signal.
        */
        
        #include <stdio.h>
        #include <sys/types.h>
        #include <unistd.h>
        #include <signal.h>
        
        void sighandler(int);
        
        int FLAG=0;
        
        int main(void)
        {
           int pid;
           struct sigaction act;
        
           pid = getpid();
           /*  set up the act data structure  */
           act.sa_handler = sighandler;      /* function to call on signal      */
           sigemptyset(&act.sa_mask);        /* start with an empty signal mask */
           act.sa_flags = 0;                 /* no special flags */
           /* set signal handling, discard old mask */
           sigaction( SIGUSR1, &act, NULL );
           if( fork() != 0 ) {
              /* parent */
              while( FLAG == 0 );
              printf("sigtest terminates\n");
           } else {
              /* child */
              sleep(5);
              kill( pid, SIGUSR1);    /* send the SIGUSR1 signal to parent */
           }
           return 0;
        }
        
        void sighandler(int sig)
        {
           if( sig == SIGUSR1 ) {
            printf("SIGNAL: SIGUSR1 is caught\n");
            FLAG = 1;
           } else {
            printf("SIGNAL: %d is caught\n",sig);
           }
        }