src/process2.c

   1 #include <stdio.h>
   2 /* exit.. */
   3 #include <stdlib.h>
   4
   5 /* open/read/write/close */
   6 #include <fcntl.h>
   7
   8 /* Signals handling.. */
   9 #include <signal.h>
  10
  11 /** If buffer is too small to hold entire string, it is incremented by this value */
  12 #define BUFFER_STEP 16
  13
  14 /** Named pipe used to communicate with process1 */
  15 char * read_pipe = "/tmp/process1pipe";
  16
  17 /** Named pipe used to communicate with process3 */
  18 char * write_pipe = "/tmp/process2pipe";
  19
  20 /** Descriptor of input pipe */
  21 int read_descriptor;
  22
  23 /** Descriptor of output pipe */
  24 int write_descriptor;
  25
  26 /**
  27  * Handler for signals.
  28  */
  29 void sig_handler(int signo)
  30 {
  31         fprintf(stderr, "[%s] Received %s!\n", "process2", strsignal(signo));
  32         if (signo == SIGUSR1) {
  33         }
  34         else if (signo == SIGTERM) {
  35                 fprintf(stderr, "[%s] > Releasing resources\n", "process2");
  36                 close(read_descriptor);
  37                 close(write_descriptor);
  38                 unlink(write_descriptor);
  39                 exit(0);
  40         }
  41         else if (signo == SIGTSTP) {
  42                 fprintf(stderr, "[%s] > Closing pipes\n", "process2");
  43                 close(read_descriptor);
  44                 close(write_descriptor);
  45                 raise (SIGSTOP);
  46         }
  47         else if (signo == SIGCONT) {
  48                 fprintf(stderr, "[%s] > Opening pipes\n", "process2");
  49                 read_descriptor = open(read_pipe, O_RDONLY);
  50                 write_descriptor = open(write_pipe, O_WRONLY);
  51         }
  52 }
  53
  54 /**
  55  * Program grabs data from process1, calculates number of characters in each line
  56  * and pass the value to process3.
  57  */
  58 int main(void) {
  59         /**
  60          * Buffer used for storing data from input pipe.
  61          * Data is stored in chunks of BUFFER_STEP size.
  62          * If data during reading is bigger than this value, then number of
  63          * characters is saved, and buffer is cleared for reading another chunk.
  64          */
  65         char buffer[BUFFER_STEP];
  66
  67         /** Index used when iterating buffer */
  68         int i = 0;
  69
  70         /** Stores number of bytes read from input pipe in current iteration */
  71         ssize_t count = 0;
  72
  73         int number_of_characters = 0;
  74
  75         fprintf(stderr, "[%s] Init!\n", "process2");
  76
  77         /**
  78          * Register signals handled by process
  79          */
  80         if (signal(SIGUSR1, sig_handler) == SIG_ERR) {
  81                 fprintf(stderr, "can't catch SIGUSR1\n");
  82         }
  83         if (signal(SIGTERM, sig_handler) == SIG_ERR) {
  84                 fprintf(stderr, "can't catch SIGTERM\n");
  85         }
  86         if (signal(SIGTSTP, sig_handler) == SIG_ERR) {
  87                 fprintf(stderr, "can't catch SIGTSTP\n");
  88         }
  89         if (signal(SIGCONT, sig_handler) == SIG_ERR) {
  90                 fprintf(stderr, "can't catch SIGCONT\n");
  91         }
  92
  93         /* Reading from process1 */
  94         read_descriptor = open(read_pipe, O_RDONLY);
  95
  96         /* Writing to process2 */
  97         mkfifo(write_pipe, 0666);
  98         write_descriptor = open(write_pipe, O_WRONLY);
  99
 100         while(1) {
 101                 /* Read data from input pipe */
 102                 count = read(read_descriptor, buffer, BUFFER_STEP);
 103
 104                 fprintf(stderr, "[%s] Fetched: %d bytes\n", "process2", count);
 105
 106                 if (count > 0) {
 107                         for (i = 0; i < count; i++, number_of_characters++) {
 108                                 if (buffer[i] == '\n') {
 109                                         fprintf(stderr, "[%s] Calculated: %d characters. Sending...\n", "process2", number_of_characters);
 110                                         write(write_descriptor, &number_of_characters, sizeof(number_of_characters));
 111                                         write(write_descriptor, '\n', 1);
 112                                         number_of_characters = 0;
 113                                 }
 114                         }
 115                 }
 116                 else {
 117                         break;
 118                 }
 119         }
 120
 121         /* Release resources in normal program flow exit. */
 122         close(read_descriptor);
 123         close(write_descriptor);
 124         unlink(write_descriptor);
 125
 126         return 0;
 127 }